home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / comm / misc / easytransfer.lzh / EasyTransfer / AmigaSource / Serial.c < prev   
Encoding:
C/C++ Source or Header  |  1995-11-11  |  9.7 KB  |  449 lines
  1.  
  2. /* Serial.c By Kamran Karimi 
  3.    Part of EasyAmiga source.
  4. */
  5. #include <dos.h>
  6.  
  7. #include <exec/types.h>
  8. #include <exec/io.h>
  9.  
  10. #include <devices/serial.h>
  11. #include <devices/timer.h>
  12.  
  13. #include <proto/exec.h>
  14.  
  15. #include <hardware/custom.h>
  16. #include <hardware/intbits.h>
  17.  
  18. extern struct Custom far custom;
  19. #define RBF 14
  20.  
  21. #include "ErrCodes.h"
  22.  
  23. #define min(a,b) (((a) <= (b)) ? (a) : (b))
  24.  
  25. extern struct PacketStruct Packet; 
  26.  
  27. #define SERTESTLEN 255
  28. #define PACKET_SIZE 255
  29. #define RECBUFFLEN 260 /* PACKET_SIZE + 5 */
  30. struct PacketStruct
  31. {
  32.  UBYTE Len;
  33.  UBYTE Data[PACKET_SIZE + 2];
  34. };
  35.  
  36. extern VOID Message(LONG MessageNum);
  37. extern LONG CheckEsc(VOID);
  38. extern VOID ShowTransfer(int Direction, UBYTE Len);
  39.  
  40. extern ULONG WorkstationWait[MAXHARDSPEED];
  41.  
  42. extern SHORT CheckSumTry; 
  43. extern char SerialName[];
  44. extern SHORT UnitNum;
  45. extern ULONG Speed[MAXHARDSPEED];
  46. extern SHORT CurrSpeed,DelayTime;
  47.  
  48. struct MsgPort *SerialMP = NULL;
  49. struct IOExtSer *SerialIO = NULL;
  50.  
  51. struct MsgPort *TimerMP = NULL;
  52. struct timerequest *TimerIO = NULL;
  53.  
  54. ULONG Serial_OK = FALSE;
  55. ULONG Timer_OK = FALSE;
  56. ULONG SystemRequest = FALSE;
  57.  
  58. LONG OpenTimer(VOID)
  59. {
  60.  LONG Unit = UNIT_VBLANK;
  61.  
  62.  if(TimerMP = CreatePort(NULL,0))
  63.  {
  64.   if(TimerIO = (struct timerequest *) 
  65.                            CreateExtIO(TimerMP,sizeof(struct timerequest)))
  66.   {
  67.    if(!OpenDevice("timer.device",Unit,(struct IORequest *)TimerIO,0))
  68.     {
  69.      Timer_OK = TRUE; 
  70.      return NO_ERROR;
  71.     }
  72.    else return ERROR_OpenDevice;
  73.   }
  74.   else return ERROR_CreateExtIO;
  75.  }
  76.  else return ERROR_CreatePort;
  77. }
  78.  
  79.  
  80. VOID CloseTimer(VOID)
  81. {
  82.  if(Timer_OK) 
  83.  { 
  84.   CloseDevice((struct IORequest *)TimerIO);
  85.   Timer_OK = FALSE;
  86.  }
  87.  if(TimerIO) { DeleteExtIO((struct IORequest *)TimerIO); TimerIO = NULL; }
  88.  if(TimerMP) { DeletePort(TimerMP); TimerMP = NULL; }
  89. }
  90.  
  91.  
  92. LONG OpenSerial(VOID)
  93. {
  94.  if(SerialMP = CreatePort(NULL,0))
  95.  {
  96.   if(SerialIO = (struct IOExtSer *)
  97.                                 CreateExtIO(SerialMP,sizeof(struct IOExtSer)))
  98.   {
  99.    SerialIO->io_SerFlags = SERF_XDISABLED;
  100.    if(!OpenDevice(SerialName,UnitNum,(struct IORequest *)SerialIO,0))
  101.     {
  102.      Serial_OK = TRUE; 
  103.      return NO_ERROR;
  104.     }
  105.    else return ERROR_OpenDevice;
  106.   }
  107.   else return ERROR_CreateExtIO;
  108.  }
  109.  else return ERROR_CreatePort;
  110. }
  111.  
  112.  
  113. LONG ActualSendPacket(USHORT Len)
  114. {
  115.  ULONG Sig;
  116.  LONG Error;
  117.  
  118.  if(Serial_OK)
  119.  {
  120.   if((Error = CheckEsc())) return Error;
  121.   if(OpenTimer()) { CloseTimer(); return ERROR_Timer; }
  122.   SerialIO->IOSer.io_Command = CMD_WRITE;
  123.   SerialIO->IOSer.io_Length = Len;
  124.   SerialIO->IOSer.io_Data = (APTR)Packet.Data;
  125.   SendIO((struct IORequest *)SerialIO);
  126.   TimerIO->tr_node.io_Command = TR_ADDREQUEST;
  127.   TimerIO->tr_time.tv_secs = 
  128.           (ULONG)( DelayTime + 2 + Len / WorkstationWait[CurrSpeed]);
  129.   TimerIO->tr_time.tv_micro = 5;
  130.   SendIO((struct IORequest *)TimerIO);
  131.   Sig = Wait(( 1 << SerialMP->mp_SigBit) | (1 << TimerMP->mp_SigBit));
  132.   if(Sig & (1 << TimerMP->mp_SigBit))
  133.   {
  134.    AbortIO((struct IORequest *)SerialIO);
  135.    WaitIO((struct IORequest *)SerialIO);
  136.  
  137.    WaitIO((struct IORequest *)TimerIO);
  138.    CloseTimer(); 
  139.    return ERROR_Timeout;
  140.   }
  141.   else
  142.   {
  143.    WaitIO((struct IORequest *)SerialIO);
  144.  
  145.    AbortIO((struct IORequest *)TimerIO);
  146.    WaitIO((struct IORequest *)TimerIO);
  147.    CloseTimer();
  148.    return NO_ERROR;
  149.   }
  150.  }
  151.  else return ERROR_NoDevice;
  152. } 
  153.  
  154. /*
  155. LONG ActualReceivePacketHard(USHORT Len)
  156. {
  157.  LONG Error;
  158.  USHORT Enable,Offset;
  159.  struct Message *TimerMsg;
  160.  
  161.  if(Serial_OK)
  162.  {
  163.   if((Error = CheckEsc())) return Error;
  164.   if(OpenTimer()) { CloseTimer(); return ERROR_Timer; }
  165.   Enable = custom.intenar;
  166.   Enable &= INTF_RBF;
  167.   custom.intena = INTF_RBF; 
  168.   Offset = 0;
  169.    TimerIO->tr_node.io_Command = TR_ADDREQUEST;
  170.   if(SystemRequest)
  171.    TimerIO->tr_time.tv_secs = 0;
  172.   else
  173.    TimerIO->tr_time.tv_secs = 
  174.             (ULONG)(DelayTime + 2 + Len / WorkstationWait[CurrSpeed]);
  175.   if(SystemRequest)
  176.    TimerIO->tr_time.tv_micro = 500;
  177.   else
  178.    TimerIO->tr_time.tv_micro = 5;
  179.   SendIO((struct IORequest *)TimerIO);
  180.   while(!(TimerMsg = GetMsg(TimerMP)))
  181.   {
  182.    if(custom.serdatr & (1 << RBF))
  183.    {
  184.     Packet.Data[Offset] = (UBYTE)(custom.serdatr & 0xFF);
  185.     Offset++;
  186.    }
  187.    if(Offset >= Len) break;
  188.   }
  189.   if(Enable)
  190.    custom.intena = INTF_RBF | INTF_SETCLR;
  191.   if(TimerMsg) 
  192.   {
  193.    ReplyMsg(TimerMsg);
  194.    CloseTimer();
  195.    return ERROR_Timeout;
  196.   }
  197.   else
  198.   {
  199.    AbortIO((struct IORequest *)TimerIO);
  200.    WaitIO((struct IORequest *)TimerIO);
  201.    CloseTimer();   
  202.    return NO_ERROR;
  203.   }
  204.  }
  205.  else return ERROR_NoDevice;
  206. }
  207. */
  208.  
  209. LONG ActualReceivePacket(USHORT Len)
  210. {
  211.  ULONG Sig;
  212.  LONG Error;
  213.  
  214.  if(Serial_OK)
  215.  {
  216.   if((Error = CheckEsc())) return Error;
  217.   if(OpenTimer()) { CloseTimer(); return ERROR_Timer; }
  218.   SerialIO->IOSer.io_Command = CMD_READ;
  219.   SerialIO->IOSer.io_Length = Len;
  220.   SerialIO->IOSer.io_Data = (APTR)Packet.Data;
  221.   SendIO((struct IORequest *)SerialIO);
  222.   TimerIO->tr_node.io_Command = TR_ADDREQUEST;
  223.   if(SystemRequest)
  224.    TimerIO->tr_time.tv_secs = 0;
  225.   else
  226.    TimerIO->tr_time.tv_secs = 
  227.             (ULONG)(DelayTime + 2 + Len / WorkstationWait[CurrSpeed]);
  228.   if(SystemRequest)
  229.    TimerIO->tr_time.tv_micro = 500;
  230.   else
  231.    TimerIO->tr_time.tv_micro = 5;
  232.   SendIO((struct IORequest *)TimerIO);
  233.   Sig = Wait(( 1 << SerialMP->mp_SigBit) | (1 << TimerMP->mp_SigBit));
  234.   if(Sig & (1 << TimerMP->mp_SigBit))
  235.   {
  236.    AbortIO((struct IORequest *)SerialIO);
  237.    WaitIO((struct IORequest *)SerialIO);
  238.  
  239.    WaitIO((struct IORequest *)TimerIO); 
  240.    CloseTimer();
  241.    return ERROR_Timeout;
  242.   }
  243.   else
  244.   {
  245.    WaitIO((struct IORequest *)SerialIO);
  246.  
  247.    AbortIO((struct IORequest *)TimerIO);
  248.    WaitIO((struct IORequest *)TimerIO);
  249.    CloseTimer();   
  250.    return NO_ERROR;
  251.   }
  252.  }
  253.  else return ERROR_NoDevice;
  254. } 
  255.  
  256.  
  257. VOID ClrSer(VOID)
  258. {
  259.  LONG UnRead,Read;
  260.  char ReadBuff[RECBUFFLEN];
  261.  
  262.  if(Serial_OK)
  263.  {
  264.   SerialIO->IOSer.io_Command = SDCMD_QUERY;
  265.   DoIO((struct IORequest *)SerialIO);
  266.   UnRead =  SerialIO->IOSer.io_Actual;
  267.   while(UnRead > 0)
  268.   {
  269.    Read = min(UnRead,RECBUFFLEN);
  270.    SerialIO->IOSer.io_Command = CMD_READ;
  271.    SerialIO->IOSer.io_Length = Read;
  272.    SerialIO->IOSer.io_Data = (APTR)ReadBuff;
  273.    DoIO((struct IORequest *)SerialIO);
  274.    UnRead -= Read;
  275.   }
  276.  }
  277. }
  278.  
  279.  
  280. LONG SendPacket(VOID)
  281. {
  282.  USHORT count;
  283.  LONG Error;
  284.  SHORT NumTry = 1;
  285.  UBYTE temp;
  286.  union Check
  287.  {
  288.   USHORT CheckWord;
  289.   UBYTE CheckByte[2];
  290.  } CheckSum;
  291.  
  292.  if(Packet.Len > 1)
  293.  {
  294.   if(NumTry <= CheckSumTry) NumTry = CheckSumTry + 1;
  295.   CheckSum.CheckWord = 0;
  296.   for(count = 0; count < Packet.Len; count++)
  297.    CheckSum.CheckWord += (USHORT)Packet.Data[count];
  298.   Packet.Data[Packet.Len] = CheckSum.CheckByte[0];
  299.   Packet.Data[Packet.Len + 1] = CheckSum.CheckByte[1];   
  300.   while(NumTry > 0)
  301.   {
  302.    if((Error = ActualSendPacket(Packet.Len + 2))) return Error;
  303.    temp = Packet.Data[0];
  304.    if((Error = ActualReceivePacket(1))) return Error;
  305.    if(Packet.Data[0] == 'Y')
  306.    {
  307.     if((Error = ActualSendPacket(1))) return Error;
  308.     Packet.Data[0] = temp;
  309.     return NO_ERROR;
  310.    }
  311.    else
  312.    {
  313.     NumTry--;
  314.    }
  315.   }
  316.   return ERROR_CheckSum;
  317.  }
  318.  else return ActualSendPacket(Packet.Len); 
  319. }
  320.  
  321. LONG ReceivePacket(VOID)
  322. {
  323.  USHORT count;
  324.  LONG Error;
  325.  SHORT NumTry = 1;
  326.  UBYTE temp;
  327.  union Check
  328.  {
  329.   USHORT CheckWord;
  330.   UBYTE CheckByte[2];
  331.  } CheckSum;
  332.  
  333.  if(Packet.Len > 1)
  334.  {
  335.   if(NumTry <= CheckSumTry) NumTry = CheckSumTry + 1;
  336.   while(NumTry > 0)
  337.   {
  338.    if((Error = ActualReceivePacket(Packet.Len + 2))) return Error;
  339.    CheckSum.CheckWord = 0;
  340.    for(count = 0; count < Packet.Len; count++)
  341.     CheckSum.CheckWord += (USHORT)Packet.Data[count];
  342.    if( (Packet.Data[Packet.Len] != CheckSum.CheckByte[0]) ||
  343.        (Packet.Data[Packet.Len + 1] != CheckSum.CheckByte[1]) )
  344.    {
  345.     NumTry--;
  346.     Packet.Data[0] = 'N';
  347.     if((Error = ActualSendPacket(1))) return Error;
  348.    }
  349.    else 
  350.    {
  351.     temp = Packet.Data[0];
  352.     Packet.Data[0] = 'Y';
  353.     if((Error = ActualSendPacket(1))) return Error;
  354.     if((Error = ActualReceivePacket(1))) return Error;
  355.     Packet.Data[0] = temp;
  356.     return NO_ERROR;
  357.    }
  358.   }
  359.   return ERROR_CheckSum;
  360.  }
  361.  else return ActualReceivePacket(Packet.Len);
  362. }
  363.  
  364.  
  365. VOID CloseSerial(VOID)
  366. {
  367.  if(Serial_OK) 
  368.  { 
  369.   CloseDevice((struct IORequest *)SerialIO);
  370.   Serial_OK = FALSE;
  371.  }
  372.  if(SerialIO) { DeleteExtIO((struct IORequest *)SerialIO); SerialIO = NULL; }
  373.  if(SerialMP) { DeletePort(SerialMP); SerialMP = NULL; }
  374. }
  375.  
  376. LONG ConfigSerial(ULONG BAUD)
  377. {
  378.  ULONG Sig;
  379.  UBYTE SerFlags = SERF_XDISABLED; 
  380.  
  381.  if(Serial_OK)
  382.  {
  383.   SerialIO->IOSer.io_Command = SDCMD_SETPARAMS;
  384.   SerialIO->io_Baud = BAUD;
  385.   SerialIO->io_ReadLen = 8;
  386.   SerialIO->io_WriteLen = 8;
  387.   SerialIO->io_StopBits = 1;
  388.   SerialIO->io_SerFlags = SerFlags;
  389.   SendIO((struct IORequest *)SerialIO);
  390.   Sig = Wait(1 << SerialMP->mp_SigBit);
  391.   WaitIO((struct IORequest *)SerialIO);  
  392.   return NO_ERROR;
  393.  }
  394.  else return ERROR_NoDevice; 
  395. }
  396.  
  397. LONG GetSynch(VOID)
  398. {
  399.  LONG Error;
  400.  
  401.  Packet.Len = 1;
  402.  if((Error = ReceivePacket())) return Error;
  403.  if(Packet.Data[0] - 150 == ERROR_CHDIR) return ERROR_CHDIR;
  404.  if(Packet.Data[0] - 150 == ERROR_MKDIR) return ERROR_MKDIR;
  405.  if(Packet.Data[0] - 150 == ERROR_RMDIR) return ERROR_RMDIR;
  406.  if(Packet.Data[0] - 150 == ERROR_SendRFile) return ERROR_SendRFile;
  407.  if(Packet.Data[0] - 150 == ERROR_RecFile) return ERROR_RecFile;
  408.  if(Packet.Data[0] - 150 == ERROR_FDelete) return ERROR_FDelete;
  409.  if(Packet.Data[0] - 150 == ERROR_SRFExists) return ERROR_SRFExists;
  410.  if(Packet.Data[0] != '!') return ERROR_NoSynch;
  411.  else return NO_ERROR;
  412. }
  413.  
  414. LONG PutSynch(VOID)
  415. {
  416.  LONG Error;
  417.  
  418.  Packet.Len = 1;
  419.  Packet.Data[0] = '?';
  420.  if((Error = SendPacket())) return Error;
  421.  else return NO_ERROR;
  422. } 
  423.  
  424. LONG PutError(long ErrNo)
  425. {
  426.  LONG Error;
  427.  
  428.  Packet.Len = 1;
  429.  Packet.Data[0] = 150 + ErrNo;
  430.  if((Error = SendPacket())) return Error;
  431.  else return NO_ERROR;
  432. } 
  433.  
  434.  
  435. LONG CheckLink(VOID)
  436. {
  437.  LONG Error;
  438.  
  439.  Packet.Len = 1;
  440.  Packet.Data[0] = 'L';
  441.  if((Error = SendPacket())) return Error;
  442.  Packet.Len = 1;
  443.  SystemRequest = TRUE;
  444.  Error = ActualReceivePacket(1);
  445.  SystemRequest = FALSE;
  446.  if(Error) return ERROR_Link;
  447.  else return NO_ERROR;
  448. }
  449.